package ljl.codetop300;

import commons.WrongAnswer;

/**
 * mat = [
 * [1,2,3],
 * [4,5,6],
 * [7,8,9]]
 * 输出：[1,2,4,7,5,3,6,8,9]
 * (0,0) (0,1) (1,0) (2,0) (1,1) (0,2) (1,2) (2,1) (2,2)
 *
 * 这个题掐死我我也想不出来
 * 人家一堆 if else 也能解决，我不能
 * 你真该死啊小夫
 */
public class _458_diagonal {


  @WrongAnswer
  static class giveup {
    public int[] findDiagonalOrder(int[][] mat) {
      return null;
    }

    int[] chooseNextPos(int rows, int cols, int i, int j, int sign) {
      int[] res;
      int nextI = i - sign;
      int nextJ = j + sign;
      if (nextI >= 0 && nextI < rows && nextJ >= 0 && nextJ < cols) {
        return new int[] {nextI, nextJ};
      }
      return null;
    }
  }

  static class biyou {
    /**
     * 00 01 02 03
     * 10 11 12 13
     * 20 21 22 23
     * 对角线方向上，下标之和，是递增的，0 1 2 3 4 5
     *
     * 但是只能处理一个方向的，怎么处理反方向？注意到，需要反方向时，x 已经到顶了，x 应该增大，y 应该减小
     * 可以互换 x y 位置，达到反向的目的：还让 x 减小，y 增大，但此时 x y 已经互换身份了
     */
    public int[] findDiagonalOrder(int[][] mat) {
      boolean flag = true;
      int m = mat.length;
      int n = mat[0].length;
      int[] res = new int[m * n];
      int idx = 0;
      for (int i = 0; i < m + n; i++) {
        int pm = flag ? m : n;
        int pn = flag ? n : m;
        int x = i < pm ? i : pm - 1;
        int y = i - x;
        while (x >= 0 && y < pn) {
          res[idx++] = flag ? mat[x][y] : mat[y][x];
          x--;
          y++;
        }
        flag = !flag;
      }
      return res;
    }
  }

}
